home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / presto / presto10.lha / src / shmalloc.c < prev    next >
C/C++ Source or Header  |  1991-12-11  |  23KB  |  859 lines
  1. /*
  2.  * This memory allocation code is derived from the GNU memory allocator.
  3.  * Please read the FSF copyright notice at the end of this file.
  4.  */
  5.  
  6. /*
  7.  * @(#)nmalloc.c 1 (Caltech) 2/21/82
  8.  *
  9.  *    U of M Modified: 20 Jun 1983 ACT: strange hacks for Emacs
  10.  *
  11.  *    Nov 1983, Mike@BRL, Added support for 4.1C/4.2 BSD.
  12.  *
  13.  * This is a very fast storage allocator.  It allocates blocks of a small 
  14.  * number of different sizes, and keeps free lists of each size.  Blocks
  15.  * that don't exactly fit are passed up to the next larger size.  In this 
  16.  * implementation, the available sizes are (2^n)-4 (or -16) bytes long.
  17.  * This is designed for use in a program that uses vast quantities of
  18.  * memory, but bombs when it runs out.  To make it a little better, it
  19.  * warns the user when he starts to get near the end.
  20.  *
  21.  * June 84, ACT: modified rcheck code to check the range given to malloc,
  22.  * rather than the range determined by the 2-power used.
  23.  *
  24.  * Jan 85, RMS: calls malloc_warning to issue warning on nearly full.
  25.  * No longer Emacs-specific; can serve as all-purpose malloc for GNU.
  26.  * You should call malloc_init to reinitialize after loading dumped Emacs.
  27.  * Call malloc_stats to get info on memory stats if MSTATS turned on.
  28.  * realloc knows how to return same block given, just changing its size,
  29.  * if the power of 2 is correct.
  30.  *
  31.  * May 88, Univ. of Washington: Significant (but relatively simple)
  32.  * changes to make this code work in a Sequent shared-memory/PRESTO
  33.  * environment.
  34.  *
  35.  * Perhaps the biggest difference is that whenever we have to ask for
  36.  * more space, we get a BIG chunk rather than a relatively small one.
  37.  * Another change is that requests for memory >= the system page size
  38.  * will return memory that is aligned to a page boundary, due to the
  39.  * prevalent use of mmap(2).
  40.  *
  41.  * June 89, Univ. of Washington: Worked on memory alignment bug in malloc().
  42.  *
  43.  * Most of the changes are bracketed by the SHARED and PRESTO $ifdef's.
  44.  *
  45.  */
  46.  
  47. #include <sys/types.h>
  48. #include "config.h"
  49.  
  50. #ifdef SHARED
  51.  
  52. #ifdef sequent
  53. #include <parallel/parallel.h> 
  54. #define sbrk shsbrk
  55. #endif /* sequent */
  56.  
  57. #ifdef sun
  58. #  define shared /**/
  59. #  define private /**/
  60.    typedef    int slock_t;
  61. #  define L_UNLOCKED 0
  62. #  ifdef PRESTO
  63. #      define S_LOCK s_lock
  64. #      define S_UNLOCK s_unlock
  65. #  endif PRESTO
  66. #endif /* sun */
  67.  
  68. #ifdef vax
  69. #define shared /**/
  70. #define private /**/
  71. typedef    int slock_t;
  72. #define L_UNLOCKED 0
  73.  
  74. #ifdef PRESTO
  75. /*
  76.  * Redefine S_LOCK and S_UNLOCK to be s_lock() and s_unlock(),
  77.  * included in vax_lock.s in Presto source.  Should probably be
  78.  * asm macros.  On the vax, the shared allocation code won't ld
  79.  * outside of a presto environment.
  80.  */
  81. #define S_LOCK s_lock
  82. #define S_UNLOCK s_unlock
  83. #else
  84. XXX
  85. #endif /* PRESTO */
  86. #endif /* vax */
  87.  
  88. #ifdef PRESTO
  89. /*
  90.  * See comment on naming of the memory allocator in misc.c.
  91.  *
  92.  * #define malloc shmalloc
  93.  * #define free shfree
  94.  */
  95.  
  96. #endif /* PRESTO */
  97.  
  98. #define mstats shmstats
  99. #define realloc shrealloc
  100.     
  101. #endif /* SHARED */
  102.  
  103. #ifdef PRESTO
  104. /*
  105.  * These external routines are needed to avoid a deadlock situation where
  106.  * we preempt a thread controlling access to the memory management 
  107.  * stuff.  Preempting while holding onto this stuff could make things
  108.  * go very very slowly.
  109.  */
  110.  
  111. extern void enable_interrupts();
  112. extern int disable_interrupts();
  113. #endif /* PRESTO */
  114.  
  115.  
  116. /*
  117.  * Determine which kind of system this is.
  118.  */
  119. #define BSD42
  120. #define BSD
  121. #include <sys/time.h>
  122. #include <sys/resource.h> 
  123.  
  124. #define ISALLOC ((char) 0xf7)    /* magic byte that implies allocation */
  125. #define ISFREE ((char) 0x54)    /* magic byte that implies free block */
  126.                 /* this is for error checking only */
  127. #define ISMEMALIGN ((char) 0xd6)  /* Stored before the value returned by
  128.                      memalign, with the rest of the word
  129.                      being the distance to the true
  130.                      beginning of the block.  */
  131.  
  132. /*
  133.  * NBINS == number of "headers" pointing to blocks of size 2**(n+3).
  134.  */
  135. #define NBINS 30
  136.  
  137. /*
  138.  * If MSTATS is defined then
  139.  * nmalloc[i] is the difference between the number of mallocs and frees
  140.  * for a given block size.
  141.  */
  142.  
  143. #ifdef MSTATS
  144. #ifdef SHARED
  145. shared static int nmalloc[NBINS];
  146. shared static int nmal, nfre;
  147. #else
  148. static int nmalloc[NBINS];
  149. static int nmal, nfre;
  150. #endif
  151. #endif /* /* MSTATS */ */
  152.  
  153. /*
  154.  * If range checking is not turned on, all we have is a flag indicating
  155.  * whether memory is allocated, an index in nextf[], and a size field; to
  156.  * realloc() memory we copy either size bytes or 1<<(index+3) bytes depending
  157.  * on whether the former can hold the exact size (given the value of
  158.  * 'index').  If range checking is on, we always need to know how much space
  159.  * is allocated, so the 'size' field is only used to remember memory alignment
  160.  */
  161.  
  162. struct mhead {
  163.     char     mh_alloc;    /* ISALLOC or ISFREE */
  164.     char     mh_index;    /* index in nextf[] */
  165. /* Remainder are valid only when block is allocated */
  166.     unsigned short mh_size;    /* size, if < 0x10000 */
  167. #ifdef rcheck
  168.     unsigned mh_nbytes;    /* number of bytes allocated */
  169.     int      mh_magic4;    /* should be == MAGIC4 */
  170. #endif /* /* rcheck */ */
  171. };
  172.  
  173. /*
  174.  * Access free-list pointer of a block.
  175.  * It is stored at block + 4.
  176.  * This is not a field in the mhead structure
  177.  * because we want sizeof (struct mhead)
  178.  * to describe the overhead for when the block is in use,
  179.  * and we do not want the free-list pointer to count in that.
  180.  */
  181.  
  182. #define CHAIN(a) \
  183.   (*(struct mhead **) (sizeof (char *) + (char *) (a)))
  184.  
  185. #ifdef rcheck
  186.  
  187. /*
  188.  * To implement range checking, we write magic values in at the beginning and
  189.  * end of each allocated block, and make sure they are undisturbed whenever a
  190.  * free or a realloc occurs.
  191.  */
  192.  
  193. /* Written in each of the 4 bytes following the block's real space */
  194. #define MAGIC1 0x55
  195.  
  196. /* Written in the 4 bytes before the block's real space */
  197. #define MAGIC4 0x55555555
  198.  
  199. #define ASSERT(p) if (!(p)) botch("p"); else
  200. #define EXTRA  4        /* 4 bytes extra for MAGIC1s */
  201.  
  202. #else
  203.  
  204. #define ASSERT(p)
  205. #define EXTRA  0
  206.  
  207. #endif /* /* rcheck */ */
  208.  
  209. /*
  210.  * nextf[i] is the pointer to the next free block of size 2^(i+3).  The
  211.  * smallest allocatable block is 8 bytes.  The overhead information will
  212.  * go in the first int of the block, and the returned pointer will point
  213.  * to the second.
  214.  *
  215.  * busy[i] is meant to indicate that a recursive call to malloc
  216.  * has been made (e.g., via a signal handler). Not used in this
  217.  * (May 88) version.
  218.  */
  219.  
  220. #ifdef SHARED
  221. /* nextf[i] is free list of blocks of size 2**(i + 3)  */
  222. shared static struct mhead *nextf[NBINS];
  223.  
  224. /* busy[i] is nonzero while allocation of block size i is in progress.  */
  225. shared static char busy[NBINS];
  226.  
  227. /* Number of bytes of writable memory we can expect to be able to get */
  228. shared static unsigned int lim_data;
  229.  
  230. /* nonzero once initial bunch of free blocks made */
  231. shared static int gotpool;
  232.  
  233. /* Mutex for structure access */
  234. shared static slock_t lock;
  235.  
  236. /* System page size in bytes */
  237. shared static int syspgsize;
  238.  
  239. #ifdef PRESTO
  240.  
  241. #define BEGIN_CRITICAL {        \
  242.     disable_interrupts();        \
  243.     S_LOCK(&lock);            \
  244. }
  245.  
  246. #define END_CRITICAL {            \
  247.     S_UNLOCK(&lock);        \
  248.     enable_interrupts();        \
  249. }
  250.  
  251. #else
  252.  
  253. #define BEGIN_CRITICAL {        \
  254.     S_LOCK(&lock);            \
  255. }
  256.  
  257. #define END_CRITICAL {            \
  258.     S_UNLOCK(&lock);        \
  259. }
  260.  
  261. #endif /* PRESTO */
  262.  
  263. #else /*    /* not shared */ */
  264.  
  265. #ifdef PRESTO
  266.  
  267. #define BEGIN_CRITICAL disable_interrupts();
  268. #define END_CRITICAL enable_interrupts();
  269.  
  270. #else
  271.  
  272. #define BEGIN_CRITICAL ;
  273. #define END_CRITICAL ;
  274.  
  275. #endif /* PRESTO */
  276.  
  277. /* nextf[i] is free list of blocks of size 2**(i + 3)  */
  278. static struct mhead *nextf[NBINS];
  279.  
  280. /* busy[i] is nonzero while allocation of block size i is in progress.  */
  281. static char busy[NBINS];
  282.  
  283. /* Number of bytes of writable memory we can expect to be able to get */
  284. static unsigned int lim_data;
  285.  
  286. /* nonzero once initial bunch of free blocks made */
  287. static int gotpool;
  288.  
  289. /* System page size in bytes */
  290. static int syspgsize;
  291.  
  292. #endif /* SHARED */
  293.  
  294. char *grab_hunk();
  295.  
  296. /*
  297.  * BRKSIZELOG2 is log2-3 of the minimum chunk of memory we will ask for
  298.  * if we have to request more memory (ie, via sbrk).  In our case we ask for
  299.  * the maximum that will fit in the mh_size field, 65K.
  300.  */
  301. #define BRKSIZELOG2 13
  302.  
  303. static morecore (nu)            /* ask system for more memory */
  304.     register int nu;        /* size index to get more of  */
  305. {
  306.     register char *cp;
  307.     register int nblks;
  308.     register unsigned int siz;
  309.  
  310.  /*
  311.   * On initial startup, get one block of each size up to some reasonable
  312.   * size.
  313.   */
  314.   if (!gotpool) {
  315.     getpool (); 
  316.     gotpool = 1;
  317.     if ( nextf[nu] ) return; /* Getpool got it for us */
  318.    }
  319.  
  320.  /*
  321.   * Must be either a big block or we are really out of memory.
  322.   */
  323.   nblks = 1;
  324.   if ((siz = nu) < BRKSIZELOG2)
  325.     nblks = 1 << ((siz = BRKSIZELOG2) - nu);
  326.  
  327.   if ((cp = grab_hunk(1 << (siz + 3))) == (char *) -1)
  328.     return;            /* no more room! */
  329.  
  330.   if ((int) cp & 7) {
  331.     /*
  332.      * shouldn't happen, but just in case
  333.      */
  334.     cp = (char *) (((int) cp + 8) & ~7);
  335.     nblks--;
  336.   }
  337.  
  338.   /*
  339.    * save new header and link the nblks blocks together
  340.    */
  341.   nextf[nu] = (struct mhead  *) cp;
  342.   siz = 1 << (nu + 3);
  343.   while (1) {
  344.     ((struct mhead *) cp) -> mh_alloc = ISFREE;
  345.     ((struct mhead *) cp) -> mh_index = nu;
  346.     if (--nblks <= 0)
  347.     break;
  348.     CHAIN ((struct mhead   *) cp) = (struct mhead  *) (cp + siz);
  349.     cp += siz;
  350.   }
  351.   CHAIN ((struct mhead   *) cp) = 0;
  352. }
  353.  
  354. /*
  355.  * Get a chunk of memory from the system.  Make sure the pointer that
  356.  * we return is just sizeof(struct mhead) bytes shy of a page boundary.
  357.  * Calls to this function must be serialized.
  358.  */
  359.  
  360. char *
  361. grab_hunk(nbytes)
  362.   int nbytes;
  363. {
  364.   char *cp;
  365.   char *sbrk ();
  366.  
  367.   cp = sbrk(0);
  368.   /*
  369.    * land on pagesize boundaries 
  370.    */
  371.   if (((int) cp + sizeof(struct mhead)) & (syspgsize-1)) {
  372.     sbrk (syspgsize - (((int) cp + sizeof( struct mhead)) & (syspgsize-1)));
  373.   }
  374.  
  375.   return(sbrk(nbytes));
  376. }
  377.  
  378. /*
  379.  * Get a chunk of memory from the system.  Make sure the pointer that
  380.  * we return is just on a page boundary.  This memory should **not**
  381.  * be used by the memory allocator.
  382.  */
  383.  
  384. char *
  385. grab_nonmalloc_hunk(nbytes)
  386.   int nbytes;
  387. {
  388.   char *cp;
  389.   char *sbrk ();
  390.  
  391.   BEGIN_CRITICAL;
  392.   cp = sbrk(0);
  393.   /*
  394.    * land on pagesize boundaries 
  395.    */
  396.   if (((int) cp) & (syspgsize-1)) {
  397.     sbrk (syspgsize - (((int) cp) & (syspgsize-1)));
  398.   }
  399.  
  400.   cp = sbrk(nbytes);
  401.   END_CRITICAL;
  402.   return cp;
  403. }
  404.  
  405. static getpool ()
  406. {
  407.   register int nu;
  408.   register char *cp;
  409.   int logpgsz;
  410.   
  411.   /* Get 16*pagesize of storage */
  412.   cp = grab_hunk(16*syspgsize);
  413.   if (cp == (char *) -1)
  414.     return;
  415.  
  416.   /*
  417.   /* Divide it into an initial 8-word block
  418.    * plus one block of size 2**nu for nu = 3 ... log2(chunksize*pgsize)-1.
  419.    */
  420.   logpgsz = 8*syspgsize;
  421.   nu = 0;
  422.   while ( ! (logpgsz & 1) ) {
  423.       logpgsz >>= 1;
  424.       nu++;
  425.   }
  426.   logpgsz = nu - 3;
  427.   
  428.   CHAIN (cp) = nextf[0];
  429.   nextf[0] = (struct mhead *) cp;
  430.   ((struct mhead *) cp) -> mh_alloc = ISFREE;
  431.   ((struct mhead *) cp) -> mh_index = 0;
  432.   cp += 8;
  433.  
  434.   for (nu = 0; nu < logpgsz; nu++)
  435.     {
  436.       CHAIN (cp) = nextf[nu];
  437.       nextf[nu] = (struct mhead *) cp;
  438.       ((struct mhead *) cp) -> mh_alloc = ISFREE;
  439.       ((struct mhead *) cp) -> mh_index = nu;
  440.       cp += 8 << nu;
  441.     }
  442. }
  443.  
  444. char *malloc (n)        /* get a block */
  445.      unsigned n;
  446. {
  447.   register struct mhead *p;
  448.   register unsigned int nbytes;
  449.   register int nunits = 0;
  450.   int mustalign;
  451.   char *aligned;
  452.   struct mhead *p2;
  453.   
  454.   /*
  455.    * Figure out how many bytes are required, rounding up to the nearest
  456.    * multiple of 4, then figure out which nextf[] area to use.
  457.    */
  458.   if ( !syspgsize ) {
  459.       syspgsize = getpagesize();
  460.   }
  461.  
  462.   /*
  463.    * If asking for >= syspgsize bytes, make sure
  464.    * the return value is page aligned in case of mmap(2).
  465.    */
  466.   if ( n >= syspgsize ) {
  467.     mustalign = 1;
  468.       n += syspgsize;
  469.   }
  470.   else {
  471.     mustalign = 0;
  472.   }
  473.     
  474.   nbytes = (n + sizeof *p + EXTRA + 3) & ~3;
  475.   {
  476.     register unsigned int   shiftr = (nbytes - 1) >> 2;
  477.  
  478.     while (shiftr >>= 1)
  479.       nunits++;
  480.   }
  481.  
  482.   BEGIN_CRITICAL;
  483.  
  484.   /* If there are no blocks of the appropriate size, go get some */
  485.   /* COULD SPLIT UP A LARGER BLOCK HERE ... ACT */
  486.   if (nextf[nunits] == 0)
  487.     morecore (nunits);
  488.  
  489.   /* Get one block off the list, and set the new list head */
  490.   if ((p = nextf[nunits]) == 0) {
  491.       END_CRITICAL;
  492.       return 0;
  493.   }
  494.  
  495.   nextf[nunits] = CHAIN (p);
  496.  
  497.   END_CRITICAL;
  498.  
  499.   /*
  500.    * Check for free block clobbered
  501.    * If not for this check, we would gobble a clobbered free chain ptr
  502.    * and bomb out on the NEXT allocate of this size block
  503.    */
  504.   if (p -> mh_alloc != ISFREE || p -> mh_index != nunits)
  505. #ifdef rcheck
  506.     botch ("block on free list clobbered");
  507. #else /* /* not rcheck */ */
  508.     abort ();
  509. #endif /* /* not rcheck */ */
  510.  
  511.   /* Fill in the info, and if range checking, set up the magic numbers */
  512.   p -> mh_alloc = ISALLOC;
  513.  
  514. #ifdef rcheck
  515.   p -> mh_nbytes = n;
  516.   p -> mh_magic4 = MAGIC4;
  517.   {
  518.     register char  *m = (char *) (p + 1) + n;
  519.  
  520.     *m++ = MAGIC1, *m++ = MAGIC1, *m++ = MAGIC1, *m = MAGIC1;
  521.   }
  522. #else /* /* not rcheck */ */
  523.   p -> mh_size = n;
  524. #endif /* /* not rcheck */ */
  525.  
  526. #ifdef MSTATS
  527.   nmalloc[nunits]++;
  528.   nmal++;
  529. #endif /* /* MSTATS */ */
  530.  
  531.   if ( mustalign ) {
  532.       if ( ((int)(p+1) & (syspgsize-1)) != 0 ) {
  533.       aligned = (char *) (p+1);
  534.       aligned = (char *) (((int)aligned + syspgsize - 1) & -syspgsize);
  535.       p2 = (struct mhead *) aligned - 1;
  536.       p2->mh_size = aligned - (char *)( p + 1 );
  537.       p2->mh_alloc = ISMEMALIGN;
  538.       return aligned;
  539.       }
  540.   }
  541.   
  542.   return (char *) (p + 1);
  543. }
  544.  
  545. free (mem)
  546.      char *mem;
  547. {
  548.   register struct mhead *p;
  549.  
  550.   {
  551.     register char *ap = mem;
  552.  
  553.     if (ap == 0)
  554.       return;
  555.  
  556.     p = (struct mhead *) ap - 1;
  557.     if (p -> mh_alloc == ISMEMALIGN)
  558.       {
  559.     ap -= p->mh_size;
  560.     p = (struct mhead *) ap - 1;
  561.       }
  562.  
  563.     if (p -> mh_alloc != ISALLOC)
  564. #ifdef rcheck
  565.       abort ();
  566. #else
  567.       return;
  568. #endif
  569. #ifdef rcheck
  570.     ASSERT (p -> mh_magic4 == MAGIC4);
  571.     ap += p -> mh_nbytes;
  572.     ASSERT (*ap++ == MAGIC1); ASSERT (*ap++ == MAGIC1);
  573.     ASSERT (*ap++ == MAGIC1); ASSERT (*ap   == MAGIC1);
  574. #endif /* /* rcheck */ */
  575.  
  576.   }
  577.  
  578.   {
  579.     register int nunits = p -> mh_index;
  580.  
  581.     ASSERT (nunits <= (NBINS-1));
  582.     p -> mh_alloc = ISFREE;
  583.  
  584.     BEGIN_CRITICAL;
  585.  
  586.     /* Put this block on the free list.  */
  587.     CHAIN (p) = nextf[nunits];
  588.     nextf[nunits] = p;
  589.  
  590. #ifdef MSTATS
  591.     nmalloc[nunits]--;
  592.     nfre++;
  593. #endif /* /* MSTATS */ */
  594.  
  595.     END_CRITICAL;
  596.   }
  597. }
  598.  
  599.  
  600. #ifdef MSTATS
  601. /*
  602.  * Return statistics describing allocation of blocks of size 2**n.
  603.  *
  604.  * This seems like a foolish way to do things, but who am I to argue
  605.  * with Stallman, et al.
  606.  */
  607.  
  608. struct mstats_value {
  609.     int blocksize;
  610.     int nfree;
  611.     int nused;
  612. };
  613.  
  614. struct mstats_value malloc_stats (size)
  615.      int size;
  616. {
  617.   struct mstats_value v;
  618.   register int i;
  619.   register struct mhead *p;
  620.  
  621.   v.nfree = 0;
  622.  
  623.   if (size < 0 || size >= NBINS)
  624.     {
  625.       v.blocksize = 0;
  626.       v.nused = 0;
  627.       return v;
  628.     }
  629.  
  630.   BEGIN_CRITICAL;
  631.   v.blocksize = 1 << (size + 3);
  632.   v.nused = nmalloc[size];
  633.   for (p = nextf[size]; p; p = CHAIN (p))
  634.     v.nfree++;
  635.   END_CRITICAL;
  636.  
  637.   return v;
  638. }
  639. #endif /* /* MSTATS */ */
  640.  
  641. char *realloc (mem, n)
  642.     char *mem;
  643.     register unsigned n;
  644. {
  645.   register struct mhead *p;
  646.   register unsigned int tocopy;
  647.   register unsigned int nbytes;
  648.   register int nunits;
  649.  
  650.   if ((p = (struct mhead *) mem) == 0)
  651.     return malloc (n);
  652.   p--;
  653.   nunits = p -> mh_index;
  654.   ASSERT (p -> mh_alloc == ISALLOC);
  655.  
  656. #ifdef rcheck
  657.   ASSERT (p -> mh_magic4 == MAGIC4);
  658.   {
  659.     register char *m = mem + (tocopy = p -> mh_nbytes);
  660.     ASSERT (*m++ == MAGIC1); ASSERT (*m++ == MAGIC1);
  661.     ASSERT (*m++ == MAGIC1); ASSERT (*m   == MAGIC1);
  662.   }
  663. #else /* /* not rcheck */ */
  664.   if (p -> mh_index >= 13)
  665.     tocopy = (1 << (p -> mh_index + 3)) - sizeof *p;
  666.   else
  667.     tocopy = p -> mh_size;
  668. #endif /* /* not rcheck */ */
  669.  
  670.   /* See if desired size rounds to same power of 2 as actual size. */
  671.   nbytes = (n + sizeof *p + EXTRA + 7) & ~7;
  672.  
  673.   /* If ok, use the same block, just marking its size as changed.  */
  674.   if (nbytes > (4 << nunits) && nbytes <= (8 << nunits))
  675.     {
  676. #ifdef rcheck
  677.       register char *m = mem + tocopy;
  678.       *m++ = 0;  *m++ = 0;  *m++ = 0;  *m++ = 0;
  679.       p-> mh_nbytes = n;
  680.       m = mem + n;
  681.       *m++ = MAGIC1;  *m++ = MAGIC1;  *m++ = MAGIC1;  *m++ = MAGIC1;
  682. #else /* /* not rcheck */ */
  683.       p -> mh_size = n;
  684. #endif /* /* not rcheck */ */
  685.       return mem;
  686.     }
  687.  
  688.   if (n < tocopy)
  689.     tocopy = n;
  690.   {
  691.     register char *new;
  692.  
  693.     if ((new = malloc (n)) == 0)
  694.       return 0;
  695.     bcopy (mem, new, tocopy);
  696.     free (mem);
  697.     return new;
  698.   }
  699. }
  700.  
  701. /*
  702.  * The following routines are not used and are left for documentation
  703.  * purposes only.
  704.  */
  705.  
  706. #ifdef NOTDEF
  707. char *memalign ( alignment, size)
  708.      unsigned alignment, size;
  709. {
  710.   register char *ptr = malloc (size + alignment);
  711.   register char *aligned;
  712.   register struct mhead *p;
  713.  
  714.   if (ptr == 0)
  715.     return 0;
  716.   /*
  717.    * If entire block has the desired alignment, just accept it.
  718.    */
  719.   if (((int) ptr & (alignment - 1)) == 0)
  720.     return ptr;
  721.   /* Otherwise, get address of byte in the block that has that alignment.  */
  722.   aligned = (char *) (((int) ptr + alignment - 1) & -alignment);
  723.   /* Store a suitable indication of how to free the block,
  724.      so that free can find the true beginning of it.  */
  725.   p = (struct mhead *) aligned - 1;
  726.   p -> mh_size = aligned - ptr;
  727.   p -> mh_alloc = ISMEMALIGN;
  728.   return aligned;
  729. }
  730.  
  731. /* This runs into trouble with getpagesize on HPUX.
  732.    Patching out seems cleaner than the ugly fix needed.
  733. char *
  734. valloc (size)
  735. {
  736.   return memalign (getpagesize (), size);
  737. }
  738. */
  739.  
  740. get_lim_data ()
  741. {
  742.   struct rlimit XXrlimit;
  743.  
  744.   getrlimit (RLIMIT_DATA, &XXrlimit);
  745. #ifdef RLIM_INFINITY
  746.   lim_data = XXrlimit.rlim_cur & RLIM_INFINITY; /* soft limit */
  747. #else
  748.   lim_data = XXrlimit.rlim_cur;    /* soft limit */
  749. #endif
  750. }
  751.  
  752. #endif /* NOTDEF */
  753.  
  754.  
  755.  
  756. /* dynamic memory allocation for GNU.
  757.    Copyright (C) 1985, 1987 Free Software Foundation, Inc.
  758.  
  759.                NO WARRANTY
  760.  
  761.   BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
  762. NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
  763. WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
  764. RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
  765. WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  766. BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  767. FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY
  768. AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE
  769. DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
  770. CORRECTION.
  771.  
  772.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
  773. STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
  774. WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
  775. LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
  776. OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
  777. USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
  778. DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
  779. A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
  780. PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
  781. DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
  782.  
  783.         GENERAL PUBLIC LICENSE TO COPY
  784.  
  785.   1. You may copy and distribute verbatim copies of this source file
  786. as you receive it, in any medium, provided that you conspicuously and
  787. appropriately publish on each copy a valid copyright notice "Copyright
  788. (C) 1985 Free Software Foundation, Inc."; and include following the
  789. copyright notice a verbatim copy of the above disclaimer of warranty
  790. and of this License.  You may charge a distribution fee for the
  791. physical act of transferring a copy.
  792.  
  793.   2. You may modify your copy or copies of this source file or
  794. any portion of it, and copy and distribute such modifications under
  795. the terms of Paragraph 1 above, provided that you also do the following:
  796.  
  797.     a) cause the modified files to carry prominent notices stating
  798.     that you changed the files and the date of any change; and
  799.  
  800.     b) cause the whole of any work that you distribute or publish,
  801.     that in whole or in part contains or is a derivative of this
  802.     program or any part thereof, to be licensed at no charge to all
  803.     third parties on terms identical to those contained in this
  804.     License Agreement (except that you may choose to grant more extensive
  805.     warranty protection to some or all third parties, at your option).
  806.  
  807.     c) You may charge a distribution fee for the physical act of
  808.     transferring a copy, and you may at your option offer warranty
  809.     protection in exchange for a fee.
  810.  
  811. Mere aggregation of another unrelated program with this program (or its
  812. derivative) on a volume of a storage or distribution medium does not bring
  813. the other program under the scope of these terms.
  814.  
  815.   3. You may copy and distribute this program (or a portion or derivative
  816. of it, under Paragraph 2) in object code or executable form under the terms
  817. of Paragraphs 1 and 2 above provided that you also do one of the following:
  818.  
  819.     a) accompany it with the complete corresponding machine-readable
  820.     source code, which must be distributed under the terms of
  821.     Paragraphs 1 and 2 above; or,
  822.  
  823.     b) accompany it with a written offer, valid for at least three
  824.     years, to give any third party free (except for a nominal
  825.     shipping charge) a complete machine-readable copy of the
  826.     corresponding source code, to be distributed under the terms of
  827.     Paragraphs 1 and 2 above; or,
  828.  
  829.     c) accompany it with the information you received as to where the
  830.     corresponding source code may be obtained.  (This alternative is
  831.     allowed only for noncommercial distribution and only if you
  832.     received the program in object code or executable form alone.)
  833.  
  834. For an executable file, complete source code means all the source code for
  835. all modules it contains; but, as a special exception, it need not include
  836. source code for modules which are standard libraries that accompany the
  837. operating system on which the executable file runs.
  838.  
  839.   4. You may not copy, sublicense, distribute or transfer this program
  840. except as expressly provided under this License Agreement.  Any attempt
  841. otherwise to copy, sublicense, distribute or transfer this program is void and
  842. your rights to use the program under this License agreement shall be
  843. automatically terminated.  However, parties who have received computer
  844. software programs from you with this License Agreement will not have
  845. their licenses terminated so long as such parties remain in full compliance.
  846.  
  847.   5. If you wish to incorporate parts of this program into other free
  848. programs whose distribution conditions are different, write to the Free
  849. Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not yet
  850. worked out a simple rule that can be stated here, but we will often permit
  851. this.  We will be guided by the two goals of preserving the free status of
  852. all derivatives of our free software and of promoting the sharing and reuse of
  853. software.
  854.  
  855.  
  856. In other words, you are welcome to use, share and improve this program.
  857. You are forbidden to forbid anyone else to use, share and improve
  858. what you give them.   Help stamp out software-hoarding!  */
  859.